home *** CD-ROM | disk | FTP | other *** search
/ Computer Inter@ctive 17 / Computer Interactive cdrom 17 - gen 99.iso / ZDNETIT / CONTENT / OPTIVDOS.ZIP / INCLUDE.ZIP / MESTD.H < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-21  |  54.6 KB  |  1,041 lines

  1. /*  MEstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "extended"
  5.   (extended-precision real numbers)
  6.  
  7.   Copyright (c) 1996-1998 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MESTD_H )
  12. #define __MESTD_H
  13. #if !defined( __MATLIB_H )
  14. #include <MatLib.h>
  15. #endif
  16. #if !defined( __VESTD_H )
  17. #include <VEstd.h>
  18. #endif
  19.  
  20. #ifdef __cplusplus
  21. extern "C" {
  22. #endif
  23.  
  24. /*************   Dynamic Generation of Matrices   ************************/
  25.  
  26. eMatrix __vf  ME_matrix(  unsigned ht, unsigned len );
  27. eMatrix __vf  ME_matrix0( unsigned ht, unsigned len );
  28.     /*  notice that, in the memory model HUGE,
  29.         neither len nor ht may exceed 3275             */
  30.  
  31. /***************************************************************************
  32.  *  The following definitions ensure compatibility between dynamically     *
  33.  *  and statically allocated matrices. The definitions are somewhat        *
  34.  *  cumbersome, but the result for you is that you need not care about     *
  35.  *  the differences between the two types.                                 *
  36.  *  (Internally, the address of the first element of any matrix is needed; *
  37.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  38.  *  but yields in either case the correct address to be passed to the      *
  39.  *  function you wish to call.)                                            *
  40.  *  Only in the rare case that you need to pass the address of one of      *
  41.  *  these functions as an argument to another function, you have to use    *
  42.  *  the actual run-time functions defined further below. Be careful with   *
  43.  *  this: future development of compilers may allow us to avoid this un-   *
  44.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  45.  *  use these run-time names.                                              *
  46.  ***************************************************************************/
  47.  
  48.  
  49. /***  Addressing single elements of dynamically allocated matrices: ******
  50.      These two functions are for compatibility with Pascal
  51.      (where elements of dynamically allocated matrices are not directly
  52.      accessible), and for getting around the pointer arithmetics bug in
  53.      some versions of Borland C++.                                         */
  54.  
  55. #define ME_Pelement( MA, ht, len, m, n ) MEPelement( MA[0], ht, len, m, n )
  56.                      /* returns a pointer to MA[m][n]. */
  57. #define ME_element( MA, ht, len, m, n ) *MEPelement( MA[0], ht, len, m, n )
  58.                      /* dereferenced pointer */
  59.  
  60.  /****************  Initialization  ***************************************
  61.  
  62.     To initialize all elements of a matrix with the same value,
  63.     or to perform arithmetic operations on all elements simultaneously,
  64.     refer to the functions of VectorLib, declared in <VEstd.h>, <VEmath.h>.
  65.     In order to use the VectorLib functions, utilize the feature that
  66.     the whole matrix occupies one contiguous area in memory: pass the
  67.     address of the first row to the desired vector function, the size
  68.     of the "vector" being ht * len.
  69.     For example, initialize all elements of the matrix MA with 1.0
  70.     (this is *NOT* the identity matrix)  by calling
  71.         VE_equ1( MA[0], ht * len );
  72. */
  73.  
  74. #define ME_equ0( MA, ht, len )            VE_equ0( MA[0], ((ui)ht)*len )
  75. #define ME_equ1( MA, len )                MEequ1( MA[0], len )
  76.                        /* this is the identity matrix */
  77. #define ME_outerprod( MA, X, Y, ht, len ) MEouterprod( MA[0], X, Y, ht, len )
  78.                        /* sizX=ht, sizY=len */
  79. #define ME_Row_equC( MA, ht, len, iRow, C ) \
  80.                                         MERow_equC( MA[0], ht, len, iRow, C )
  81. #define ME_Col_equC( MA, ht, len, iCol, C ) \
  82.                                         MECol_equC( MA[0], ht, len, iCol, C )
  83. #define ME_Dia_equC( MA, len, C )       MEDia_equC( MA[0], len, C )
  84.  
  85. #define ME_Row_equV( MA, ht, len, iRow, X ) \
  86.                                         MERow_equV( MA[0], ht, len, iRow, X )
  87. #define ME_Col_equV( MA, ht, len, iCol, X ) \
  88.                                         MECol_equV( MA[0], ht, len, iCol, X )
  89. #define ME_Dia_equV( MA, len, X )       MEDia_equV( MA[0], len, X )
  90.  
  91. #define ME_equM( MB, MA, ht, len )  VE_equV( MB[0], MA[0], (ui)(ht)*(len) )
  92.  
  93. #define ME_UequL( MA, len ) MEUequL( MA[0], len )
  94. #define ME_LequU( MA, len ) MELequU( MA[0], len )
  95.          /* copy lower-diagonal elements into upper-diagonal
  96.            (or vice versa) by index-reflection, so as to
  97.            get a symmetric matrix    */
  98.  
  99.             /* data-type conversions:  */
  100. #define M_EtoF( MF, ME, ht, len ) V_EtoF( MF[0], ME[0], ((ui)ht)*len )
  101. #define M_FtoE( ME, MF, ht, len ) V_FtoE( ME[0], MF[0], ((ui)ht)*len )
  102. #define M_EtoD( MD, ME, ht, len ) V_EtoD( MD[0], ME[0], ((ui)ht)*len )
  103. #define M_DtoE( ME, MD, ht, len ) V_DtoE( ME[0], MD[0], ((ui)ht)*len )
  104.  
  105.             /* suitable windows for ME_spectrum: */
  106. #define ME_Hanning( MA, ht, len )  MEHanning( MA[0], ht, len )
  107. #define ME_Parzen( MA, ht, len )   MEParzen( MA[0], ht, len )
  108. #define ME_Welch( MA, ht, len )    MEWelch( MA[0], ht, len )
  109.  
  110.  
  111. /********  Extracting a submatrix and copying a submatrix back  *********/
  112.  
  113. #define ME_submatrix( MSub, subHt, subLen, \
  114.                       MSrce, srceHt, srceLen, \
  115.                       firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  116.                MEsubmatrix(  MSub[0], subHt, subLen, \
  117.                              MSrce[0], srceHt, srceLen, \
  118.                              firstRowInCol, sampInCol, firstColInRow, sampInRow )
  119.  
  120. #define ME_submatrix_equM( MDest, destHt, destLen, \
  121.                            firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  122.                            MSrce, srceHt, srceLen ) \
  123.                MEsubmatrix_equM(  MDest[0], destHt, destLen, \
  124.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  125.                              MSrce[0], srceHt, srceLen )
  126.  
  127. /*****   Extracting a single row or a single column or the diagonal  ******
  128.  *       and storing it into a vector                                     */
  129.  
  130. #define ME_Row_extract( Y, MA, ht, len, iRow ) \
  131.                                      MERow_extract( Y, MA[0], ht, len, iRow )
  132. #define ME_Col_extract( Y, MA, ht, len, iCol ) \
  133.                                      MECol_extract( Y, MA[0], ht, len, iCol )
  134. #define ME_Dia_extract( Y, MA, len ) MEDia_extract( Y, MA[0], len )
  135.  
  136.  
  137. /*****************    Basic arithmetic operations *********************
  138.                       performed on one single row,
  139.                       or one single column of any matrix,
  140.                       or on the diagonal of a square matrix
  141.  
  142.     Note: In contrast to the analogous VectorLib functions, the operations
  143.     are performed in-place, i.e. the input matrix itself is changed  */
  144.  
  145. #define ME_Row_addC( MA, ht, len, iRow, C ) \
  146.                                      MERow_addC( MA[0], ht, len, iRow, C )
  147. #define ME_Col_addC( MA, ht, len, iCol, C ) \
  148.                                      MECol_addC( MA[0], ht, len, iCol, C )
  149. #define ME_Dia_addC( MA, len, C )    MEDia_addC( MA[0], len, C )
  150.  
  151. #define ME_Row_addV( MA, ht, len, iRow, X ) \
  152.                                      MERow_addV( MA[0], ht, len, iRow, X )
  153. #define ME_Col_addV( MA, ht, len, iCol, X ) \
  154.                                      MECol_addV( MA[0], ht, len, iCol, X )
  155. #define ME_Dia_addV( MA, len, X )    MEDia_addV( MA[0], len, X )
  156.  
  157. #define ME_Row_subC( MA, ht, len, iRow, C ) \
  158.                                      MERow_addC( MA[0], ht, len, iRow, (-C) )
  159. #define ME_Col_subC( MA, ht, len, iCol, C ) \
  160.                                      MECol_addC( MA[0], ht, len, iCol, (-C) )
  161. #define ME_Dia_subC( MA, len, C )    MEDia_addC( MA[0], len, (-C) )
  162.  
  163. #define ME_Row_subV( MA, ht, len, iRow, X ) \
  164.                                      MERow_subV( MA[0], ht, len, iRow, X )
  165. #define ME_Col_subV( MA, ht, len, iCol, X ) \
  166.                                      MECol_subV( MA[0], ht, len, iCol, X )
  167. #define ME_Dia_subV( MA, len, X )    MEDia_subV( MA[0], len, X )
  168.  
  169. #define ME_Row_subrC( MA, ht, len, iRow, C ) \
  170.                                      MERow_subrC( MA[0], ht, len, iRow, C )
  171. #define ME_Col_subrC( MA, ht, len, iCol, C ) \
  172.                                      MECol_subrC( MA[0], ht, len, iCol, C )
  173. #define ME_Dia_subrC( MA, len, C )   MEDia_subrC( MA[0], len, C )
  174.  
  175. #define ME_Row_subrV( MA, ht, len, iRow, X ) \
  176.                                      MERow_subrV( MA[0], ht, len, iRow, X )
  177. #define ME_Col_subrV( MA, ht, len, iCol, X ) \
  178.                                      MECol_subrV( MA[0], ht, len, iCol, X )
  179. #define ME_Dia_subrV( MA, len, X )   MEDia_subrV( MA[0], len, X )
  180.  
  181. #define ME_Row_mulC( MA, ht, len, iRow, C ) \
  182.                                      MERow_mulC( MA[0], ht, len, iRow, C )
  183. #define ME_Col_mulC( MA, ht, len, iCol, C ) \
  184.                                      MECol_mulC( MA[0], ht, len, iCol, C )
  185. #define ME_Dia_mulC( MA, len, C )    MEDia_mulC( MA[0], len, C )
  186.  
  187. #define ME_Row_mulV( MA, ht, len, iRow, X ) \
  188.                                      MERow_mulV( MA[0], ht, len, iRow, X )
  189. #define ME_Col_mulV( MA, ht, len, iCol, X ) \
  190.                                      MECol_mulV( MA[0], ht, len, iCol, X )
  191. #define ME_Dia_mulV( MA, len, X )    MEDia_mulV( MA[0], len, X )
  192.  
  193. #define ME_Row_divC( MA, ht, len, iRow, C ) \
  194.                                      MERow_divC( MA[0], ht, len, iRow, C )
  195. #define ME_Col_divC( MA, ht, len, iCol, C ) \
  196.                                      MECol_divC( MA[0], ht, len, iCol, C )
  197. #define ME_Dia_divC( MA, len, C )    MEDia_divC( MA[0], len, C )
  198.  
  199. #define ME_Row_divV( MA, ht, len, iRow, X ) \
  200.                                       MERow_divV( MA[0], ht, len, iRow, X )
  201. #define ME_Col_divV( MA, ht, len, iCol, X ) \
  202.                                       MECol_divV( MA[0], ht, len, iCol, X )
  203. #define ME_Dia_divV( MA, len, X )     MEDia_divV( MA[0], len, X )
  204.  
  205. #define ME_Row_divrC( MA, ht, len, iRow, C ) \
  206.                                       MERow_divrC( MA[0], ht, len, iRow, C )
  207. #define ME_Col_divrC( MA, ht, len, iCol, C ) \
  208.                                       MECol_divrC( MA[0], ht, len, iCol, C )
  209. #define ME_Dia_divrC( MA, len, C )    MEDia_divrC( MA[0], len, C )
  210.  
  211. #define ME_Row_divrV( MA, ht, len, iRow, X ) \
  212.                                       MERow_divrV( MA[0], ht, len, iRow, X )
  213. #define ME_Col_divrV( MA, ht, len, iCol, X ) \
  214.                                       MECol_divrV( MA[0], ht, len, iCol, X )
  215. #define ME_Dia_divrV( MA, len, X )    MEDia_divrV( MA[0], len, X )
  216.  
  217.  
  218. /******  One-dimensional vector operations **********************
  219.          performed along all rows or all columns simultaneously,
  220.          or along the diagonal of a square matrix                */
  221.  
  222. #define ME_Rows_max( Y, MA, ht, len )     MERows_max( Y, MA[0], ht, len )
  223. #define ME_Cols_max( Y, MA, ht, len )     MECols_max( Y, MA[0], ht, len )
  224. #define ME_Dia_max(  MA, len )            MEDia_max(  MA[0], len )
  225. #define ME_Rows_min( Y, MA, ht, len )     MERows_min( Y, MA[0], ht, len )
  226. #define ME_Cols_min( Y, MA, ht, len )     MECols_min( Y, MA[0], ht, len )
  227. #define ME_Dia_min(  MA, len )            MEDia_min(  MA[0], len )
  228.  
  229. #define ME_Rows_absmax( Y, MA, ht, len )  MERows_absmax( Y, MA[0], ht, len )
  230. #define ME_Cols_absmax( Y, MA, ht, len )  MECols_absmax( Y, MA[0], ht, len )
  231. #define ME_Dia_absmax(  MA, len )         MEDia_absmax(  MA[0], len )
  232. #define ME_Rows_absmin( Y, MA, ht, len )  MERows_absmin( Y, MA[0], ht, len )
  233. #define ME_Cols_absmin( Y, MA, ht, len )  MECols_absmin( Y, MA[0], ht, len )
  234. #define ME_Dia_absmin(  MA, len )         MEDia_absmin(  MA[0], len )
  235.  
  236. #define ME_Rows_sum( Y, MA, ht, len )     MERows_sum( Y, MA[0], ht, len )
  237. #define ME_Cols_sum( Y, MA, ht, len )     MECols_sum( Y, MA[0], ht, len )
  238. #define ME_Dia_sum(  MA, len )            MEDia_sum(  MA[0], len )
  239. #define ME_Rows_prod( Y, MA, ht, len )    MERows_prod( Y, MA[0], ht, len )
  240. #define ME_Cols_prod( Y, MA, ht, len )    MECols_prod( Y, MA[0], ht, len )
  241. #define ME_Dia_prod(  MA, len )           MEDia_prod(  MA[0], len )
  242.  
  243. #define ME_Rows_runsum( MA, ht, len )     MERows_runsum( MA[0], ht, len )
  244. #define ME_Cols_runsum( MA, ht, len )     MECols_runsum( MA[0], ht, len )
  245. #define ME_Rows_runprod( MA, ht, len )    MERows_runprod( MA[0], ht, len )
  246. #define ME_Cols_runprod( MA, ht, len )    MECols_runprod( MA[0], ht, len )
  247.  
  248. #define ME_Rows_rotate( MA, ht, len, pos) MERows_rotate( MA[0], ht, len, pos )
  249. #define ME_Cols_rotate( MA, ht, len, pos) MECols_rotate( MA[0], ht, len, pos )
  250. #define ME_Rows_reflect( MA, ht, len )    MERows_reflect( MA[0], ht, len )
  251. #define ME_Cols_reflect( MA, ht, len )    MECols_reflect( MA[0], ht, len )
  252.  
  253. /********  Operations involving two rows or two colums of one matrix  *****/
  254.  
  255. #define ME_Rows_exchange( MA, ht, len, row1, row2 ) \
  256.                              MERows_exchange( MA[0], ht, len, row1, row2 )
  257. #define ME_Cols_exchange( MA, ht, len, col1, col2 ) \
  258.                              MECols_exchange( MA[0], ht, len, col1, col2 )
  259.  
  260. #define ME_Rows_add( MA, ht, len, destRow, srceRow ) \
  261.                              MERows_add( MA[0], ht, len, destRow, srceRow )
  262. #define ME_Cols_add( MA, ht, len, destCol, srceCol ) \
  263.                              MECols_add( MA[0], ht, len, destCol, srceCol )
  264.                          /* dest[i] += source[i]  */
  265.  
  266. #define ME_Rows_sub( MA, ht, len, destRow, srceRow ) \
  267.                              MERows_sub( MA[0], ht, len, destRow, srceRow )
  268. #define ME_Cols_sub( MA, ht, len, destCol, srceCol ) \
  269.                              MECols_sub( MA[0], ht, len, destCol, srceCol )
  270.                          /* dest[i] -= source[i]  */
  271.  
  272. #define ME_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  273.                           MERows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  274. #define ME_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  275.                           MECols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  276.                          /* dest[i] += C * source[i]  */
  277.  
  278. #define ME_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  279.             MERows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  280. #define ME_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  281.             MECols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  282.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  283.  
  284.  
  285. /*************************  Transposing a matrix **********************/
  286.  
  287. #define ME_transpose( MTr, MA, htTr, lenTr ) \
  288.              MEtranspose( MTr[0], MA[0], htTr, lenTr )
  289.        /*  dimensions htTr, lenTr are those of the transposed matrix,
  290.            not of the original!                */
  291.  
  292.  
  293. /************************ Matrix Multiplication *************************/
  294.  
  295. #define ME_mulV( Y, MA, X, htA, lenA ) \
  296.                     MEmulV( Y, MA[0], X, htA, lenA )
  297.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  298.                               both X and Y are column-vectors    */
  299. #define VE_mulM( Y, X, MA, sizX, lenA ) \
  300.                     VEmulM( Y, X, MA[0], sizX, lenA )
  301.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  302.                              both X and Y are row-vectors.
  303.                              Mind the prefix: VE_ (not ME_)    */
  304. #define ME_mulM( MC, MA, MB, htA, lenA, lenB ) \
  305.                     MEmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  306.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  307.  
  308.  
  309. /*************************  Linear Algebra    *****************************/
  310.  
  311.    /*  The standard treatment of linear systems is based
  312.        on LUD (matrix decomposition into Upper-triangular
  313.        and Lower-triangular components). The result of the
  314.        decomposition step is used for further operations.  */
  315.  
  316. #define ME_LUdecompose( MLU, Ind, MA, len ) \
  317.                     MELUdecompose( MLU[0], Ind, MA[0], len )
  318.             /* returns "permut" = ±1 which is needed for ME_LUdet.
  319.                for singularities not cured by editing, permut is 0  */
  320. int     __vf ME_LUDresult( void );
  321.     /* returns 0, if ME_LUdecompose was successful;
  322.        returns 1, if MA was (nearly) singular in ME_LUdecompose.   */
  323. void       __vf ME_LUDsetEdit( extended Thresh );
  324. extended   __vf ME_LUDgetEdit( void );
  325.      /*  Editing threshold valid for ME_LUdecompose;
  326.          may be used to cure singularities           */
  327.  
  328. #define ME_LUsolve( X, MLU, B, Ind, len ) \
  329.                     MELUsolve( X, MLU[0], B, Ind, len )
  330. #define ME_LUinv( MInv, MLU, Ind, len ) \
  331.                     MELUinv( MInv[0], MLU[0], Ind, len )
  332. #define ME_LUdet( MLU, len, permut )  MELUdet( MLU[0], len, permut )
  333. #define ME_LUimprove( X, B, MA, MLU, Ind, len ) \
  334.                       MELUimprove( X, B, MA[0], MLU[0], Ind, len )
  335.  
  336.     /****  Special treatment of over- or under-determined
  337.            linear systems, i.e. of matrices with len != ht
  338.            and of singular matrices:
  339.            SVD (Singular Value Decomposition)       ****/
  340.  
  341. #define ME_SVdecompose( MU, MV, W, MA, htA, lenA ) \
  342.                     MESVdecompose( MU[0], MV[0], W, MA[0], htA, lenA )
  343.             /*  sizB = htA,  sizX = sizW = htV = lenV = lenA  */
  344. #define ME_SVsolve( X, MU, MV, W, B, htU, lenU ) \
  345.                     MESVsolve( X, MU[0], MV[0], W, B, htU, lenU )
  346.             /*  lenU = lenA,  htU = max( lenA, htA ) as fed into
  347.                 MD_SVdecompose   */
  348. #define ME_SVimprove( X, B, MA, MU, MV, W, htA, lenA ) \
  349.                     MESVimprove( X, B, MA[0], MU[0], MV[0], W, htA, lenA )
  350. void    __vf ME_SVDsetEdit( extended Thresh );
  351. extended   __vf ME_SVDgetEdit( void );
  352.     /* Override of the standard values for editing threshholds
  353.        in ME_SVsolve. Calling ME_setEdit with Thresh=0.0 means
  354.        that you do the necessary editing of W yourself
  355.        before calling MD_SVsolve                           */
  356.  
  357.  /*****  "Easy-to-use" versions of the matrix functions
  358.           using LUD or SVD.
  359.           They allocate their own working space and rely
  360.           on your setting of the editing threshold. In
  361.           case of memory stress, you might better use the
  362.           two-step methods declared above.            ***/
  363. #define ME_solve( X, MA, B, len ) \
  364.                     MEsolve( X, MA[0], B, len )
  365. #define ME_inv( MInv, MA, len ) \
  366.                     MEinv( MInv[0], MA[0], len )
  367. #define ME_det(  MA, len ) \
  368.                     MEdet( MA[0], len )
  369. #define ME_solveBySVD( X, MA, B, ht, len ) \
  370.                     MEsolveBySVD( X, MA[0], B, ht, len )
  371.          /*  sizX = len,  sizB = ht  */
  372. #define ME_safeSolve( X, MA, B, len ) \
  373.                     MEsafeSolve( X, MA[0], B, len )
  374.         /* ME_safeSolve tries first LUD. If that fails, SVD is done.
  375.            X[i] will be 0.0 instead of INF for those i corresponding
  376.            to singularities. If even SVD fails, all X[i] are set to 0.0.
  377.            return value 0: success via LUD; 1: success via SVD; -1: failure */
  378.  
  379.       /*********  Eigenvalues and Eigenvectors  ********/
  380.       /*** only the most frequent case of symmetric real matrices
  381.            is covered here! *********/
  382.  
  383. #define MEsym_eigenvalues( EigV, EigM, MA, len, CalcEigenVec ) \
  384.                     MEs_eigenvalues( EigV, EigM[0], MA[0], len, CalcEigenVec )
  385.                         /*  Eigenvalues are returned in EigV,
  386.                             Eigenvectors are returned as the columns of EigM.
  387.                             CalcEigenVec = 0 means that only eigenvalues
  388.                             are needed; CalcEigenVec != 0 means that
  389.                             also eigenvectors are calculated.
  390.                             Even if eigenvectors are not desired, EigM is
  391.                             needed by the function as working-space. The, on
  392.                             output, it will contain just rubbish.
  393.                             MA may be overwritten by EigM. */
  394.  
  395.  
  396. /***************** Two-Dimensional Fourier-Transform Methods ************/
  397.  
  398. void      __vf   VE_setRspEdit( eComplex Trunc );
  399. eComplex  __vf   VE_getRspEdit( void );
  400.            /* these are the same functions as used
  401.               in the one-dimensional case */
  402.  
  403. #define MEl_FFT( MY, MX, ht, len, dir )     MElFFT( MY[0], MX[0], ht, len, dir )
  404. #define MEs_FFT( MY, MX, ht, len, dir )     MEsFFT( MY[0], MX[0], ht, len, dir )
  405. #define MEl_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  406.                   MElconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  407. #define MEl_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  408.                   MEldeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  409. #define MEl_filter( MY, MX, MFlt, ht, len ) MElfilter( MY[0], MX[0], MFlt[0], ht, len )
  410. #define MEl_autocorr( MACorr, MX, ht, len ) MElautocorr( MACorr[0], MX[0], ht, len )
  411. #define MEl_xcorr( MXCorr, MX, MY, ht, len) MElxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  412. #define MEl_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  413.               MElspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  414.                 /* htSpec, lenSpec must be 2**n,
  415.                    MSpec must be a (htSpec+1)*(lenSpec+1) matrix!!
  416.                    htX >= n*htSpec,  lenX >= n*lenSpec,
  417.                    htWin = 2*htSpec, lenWin = 2*lenSpec */
  418.  
  419. #define MEs_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  420.                   MEsconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  421. #define MEs_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  422.                   MEsdeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  423. #define MEs_filter( MY, MX, MFlt, ht, len ) MEsfilter( MY[0], MX[0], MFlt[0], ht, len )
  424. #define MEs_autocorr( MACorr, MX, ht, len ) MEsautocorr( MACorr[0], MX[0], ht, len )
  425. #define MEs_xcorr( MXCorr, MX, MY, ht, len) MEsxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  426. #define MEs_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  427.               MEsspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  428.                 /* htSpec, lenSpec must be 2**n,
  429.                    MSpec has [htSpec+1][lenSpec+1] elements (!)
  430.                    htX >= n*htSpec,  lenX >= n*lenSpec,
  431.                    htWin = 2*htSpec, lenWin = 2*lenSpec     */
  432.  
  433. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  434.    #define ME_FFT         MEl_FFT
  435.    #define ME_convolve    MEl_convolve
  436.    #define ME_deconvolve  MEl_deconvolve
  437.    #define ME_filter      MEl_filter
  438.    #define ME_autocorr    MEl_autocorr
  439.    #define ME_xcorr       MEl_xcorr
  440.    #define ME_spectrum    MEl_spectrum
  441. #else
  442.    #define ME_FFT         MEs_FFT
  443.    #define ME_convolve    MEs_convolve
  444.    #define ME_deconvolve  MEs_deconvolve
  445.    #define ME_filter      MEs_filter
  446.    #define ME_autocorr    MEs_autocorr
  447.    #define ME_xcorr       MEs_xcorr
  448.    #define ME_spectrum    MEs_spectrum
  449. #endif
  450.  
  451.  
  452. /************************** Data Fitting *********************************
  453.  
  454.   Notice that some of these functions have the prefix VE_, others ME_.
  455.   This depends on the form in which the data to be fitted are recorded:
  456.   vectors are fitted by the VE_ functions, matrices by the ME_ functions.
  457.   All of these functions employ matrix methods internally. The weighted
  458.   versions return covariances in a matrix "Covar". So they are all
  459.   contained in MatrixLib and declared here.
  460. */
  461.  
  462. void __vf VE_polyfit( eVector A, unsigned deg, eVector X, eVector Y, ui sizex );
  463. #define   VE_polyfitwW( A, Covar, deg, X, Y, InvVar, sizex ) \
  464.           VEpolyfitwW( A, Covar[0], deg, X, Y, InvVar, sizex )
  465.        /* the size of A is deg+1 and Covar has [deg+1][deg+1] elements! */
  466.  
  467. void __vf VE_linfit( eVector A, iVector AStatus, unsigned npars,
  468.                      eVector X, eVector Y, ui sizex,
  469.                      void (*funcs)(eVector BasFuncs, extended x, unsigned nfuncs) );
  470. #define   VE_linfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, funcs ) \
  471.           VElinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, funcs )
  472. #define   ME_linfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, funcs ) \
  473.           MElinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, funcs )
  474. #define   ME_linfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, funcs ) \
  475.           MElinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, funcs )
  476.  
  477. void  __vf VE_setLinfitNeglect( extended Thresh );
  478.                    /* neglect A[i]=0, if significance smaller than Thresh */
  479. extended __vf VE_getLinfitNeglect( void );
  480.  
  481. extended __vf VE_nonlinfit( eVector A, iVector AStatus, unsigned npars,
  482.                     eVector X, eVector Y, ui sizex,
  483.                     void (*modelfunc)(eVector YModel, eVector XModel, ui size),
  484.                     void (*derivatives)(eVector dYdAi,eVector X, ui size, unsigned i) );
  485.             /* returns figure-of-merit of best A. If you don't know the partial
  486.                derivatives with respect to A, call with derivatives=NULL */
  487. #define   VE_nonlinfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv ) \
  488.           VEnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv )
  489. #define   ME_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, modelfunc, deriv ) \
  490.           MEnonlinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, modelfunc, deriv )
  491. #define   ME_nonlinfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, modelfunc, deriv ) \
  492.           MEnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, modelfunc, deriv )
  493.  
  494.         /* If you know some partial derivatives, you may call these functions
  495.            for those parameters for which you do not know them:           */
  496. void     __vf VE_nonlinfit_autoDeriv( eVector dYdAi, eVector X, ui size, unsigned ipar );
  497. void     __vf VE_nonlinfitwW_autoDeriv( eVector dYdAi, eVector X, ui size, unsigned ipar );
  498. void     __vf ME_nonlinfitwW_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned ipar );
  499. void     __vf ME_nonlinfit_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned ipar );
  500.        /* The following functions allow to monitor the progress of
  501.           a nonlinear fitting procedure or to manually stop it:     */
  502. extended __vf VE_nonlinfit_getChi2( void );
  503. extended __vf VE_nonlinfitwW_getChi2( void );
  504. extended __vf ME_nonlinfit_getChi2( void );
  505. extended __vf ME_nonlinfitwW_getChi2( void );
  506. void     __vf VE_nonlinfit_getBestA( eVector ABest );
  507. void     __vf VE_nonlinfitwW_getBestA( eVector ABest );
  508. void     __vf ME_nonlinfit_getBestA( eVector ABest );
  509. void     __vf ME_nonlinfitwW_getBestA( eVector ABest );
  510. unsigned __vf VE_nonlinfit_getTestRun( void );
  511. unsigned __vf VE_nonlinfitwW_getTestRun( void );
  512. unsigned __vf ME_nonlinfit_getTestRun( void );
  513. unsigned __vf ME_nonlinfitwW_getTestRun( void );
  514. unsigned __vf VE_nonlinfit_getTestPar( void );
  515. unsigned __vf VE_nonlinfitwW_getTestPar( void );
  516. unsigned __vf ME_nonlinfit_getTestPar( void );
  517. unsigned __vf ME_nonlinfitwW_getTestPar( void );
  518. int      __vf VE_nonlinfit_getTestDir( void );
  519. int      __vf VE_nonlinfitwW_getTestDir( void );
  520. int      __vf ME_nonlinfit_getTestDir( void );
  521. int      __vf ME_nonlinfitwW_getTestDir( void );
  522. void     __vf VE_nonlinfit_stop( void );
  523. void     __vf VE_nonlinfitwW_stop( void );
  524. void     __vf ME_nonlinfit_stop( void );
  525. void     __vf ME_nonlinfitwW_stop( void );
  526.  
  527. #ifdef __BORLANDC__
  528.     #pragma option -a-  /* avoid insertion of dummy bytes */
  529. #else   /* MS Visual C++ */
  530.     #pragma pack(push,1)
  531. #endif    /*  Borland or Microsoft */
  532. typedef struct VE_NONLINFITOPTIONS
  533. {
  534.       int        FigureOfMerit;  /*  0:least squares, 1:robust */
  535.              /* Convergence conditions: if the changes achieved
  536.                 in successive iterations are lower than any of the
  537.                 following values, this signals convergence. Set
  538.                 criteria to 0.0, if not applicable              */
  539.       extended   AbsTolChi,  /* absolute change of chi */
  540.                  FracTolChi, /* fractional change of chi */
  541.                  AbsTolPar,  /* absolute change of all parameters */
  542.                  FracTolPar; /* fractional change of all parameters */
  543.       unsigned   HowOftenFulfill; /* how often fulfill the above conditions? */
  544.       unsigned   LevelOfMethod;  /* 1: Levenberg-Marquardt method,
  545.                                     2: Downhill Simplex (Nelder and Mead) method,
  546.                                     3: both methods alternating;
  547.                                     add 4 to this in order to try
  548.                                        breaking out of local minima;
  549.                                     0: no fit, calculate only chi2 (and Covar) */
  550.       unsigned   LevMarIterations; /* max.number of successful iterations of LevMar */
  551.       unsigned   LevMarStarts; /* number of starts per LevMar run */
  552.       extended   LambdaStart,
  553.                  LambdaMin, LambdaMax,
  554.                  LambdaDiv, LambdaMul;    /* LevMar parameter lambda */
  555.       unsigned   DownhillIterations; /* max.number of successful iterations in Downhill */
  556.       extended   DownhillReflection,  /* re-shaping of the simplex */
  557.                  DownhillContraction,
  558.                  DownhillExpansion;
  559.       unsigned   TotalStarts;  /* max. number of LevMar/Downhill pairs */
  560.       eVector    UpperLimits;  /* impose upper limits on parameters */
  561.       eVector    LowerLimits;  /* impose lower limits on parameters */
  562.       void       (*Restrictions)(void);  /* user-defined editing of parameters */
  563. }  VE_NONLINFITOPTIONS;
  564.  
  565. void __vf VE_setNonlinfitOptions( VE_NONLINFITOPTIONS *Options );
  566. void __vf VE_getNonlinfitOptions( VE_NONLINFITOPTIONS *Options );
  567.  
  568. typedef struct VE_EXPERIMENT
  569. {
  570.     eVector    X, Y, InvVar;
  571.     ui         size;
  572.     extended   WeightOfExperiment;
  573.      /* InvVar and WeightOfExperiment are needed only for the
  574.         weighted variants of the multifit functions */
  575. } VE_EXPERIMENT;
  576.  
  577. typedef struct ME_EXPERIMENT
  578. {
  579.     eVector      X, Y;
  580.     eMatrix      MZ, MInvVar;  /* here no compatibility with static matrices! */
  581.     unsigned     htZ, lenZ;
  582.     extended     WeightOfExperiment;
  583.      /* MInvVar and WeightOfExperiment are needed only for the
  584.         weighted variants of the multifit functions */
  585. } ME_EXPERIMENT;
  586. #ifdef __BORLANDC__
  587.     #pragma option -a.   /* restore default data packing  */
  588. #else   /* MS Visual C++ */
  589.     #pragma pack(pop)
  590. #endif
  591.  
  592.  
  593. void __vf VE_multiLinfit( eVector A, iVector AStatus, unsigned ma,
  594.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  595.                 void (*funcs)(eVector BasFuncs, extended x,
  596.                               unsigned nfuncs, unsigned iexperiment) );
  597. #define   VE_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  598.           VEmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  599. void __vf ME_multiLinfit( eVector A, iVector AStatus, unsigned ma,
  600.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  601.                 void (*funcs)(eVector BasFuncs, extended x, extended y,
  602.                               unsigned nfuncs, unsigned iexperiment) );
  603. #define   ME_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  604.           MEmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  605. extended __vf VE_multiNonlinfit( eVector A, iVector AStatus, unsigned npars,
  606.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  607.                 void (*modelfunc)(eVector YModel, eVector XModel,
  608.                                   ui size, unsigned iexperiment),
  609.                 void (*derivatives)(eVector dYdAi,eVector X, ui size,
  610.                                    unsigned ipar, unsigned iexperiment) );
  611.             /* returns figure-of-merit of best A. If you don't know the
  612.                partial derivatives, set derivatives=NULL */
  613. #define   VE_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  614.           VEmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  615. extended __vf ME_multiNonlinfit( eVector A, iVector AStatus, unsigned npars,
  616.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  617.                 void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ,
  618.                                   eVector X, eVector Y, unsigned iexperiment),
  619.                 void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  620.                                     eVector X, eVector Y, unsigned ipar,
  621.                                     unsigned iexperiment) );
  622. #define   ME_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  623.           MEmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  624.  
  625. void  __vf VE_multiNonlinfit_autoDeriv( eVector dYdAi, eVector X, ui size,
  626.                                        unsigned iexperiment, unsigned ipar );
  627. void  __vf VE_multiNonlinfitwW_autoDeriv( eVector dYdAi, eVector X, ui size,
  628.                                        unsigned iexperiment, unsigned ipar );
  629. void  __vf ME_multiNonlinfit_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  630.                                     eVector X, eVector Y,
  631.                                     unsigned ipar, unsigned iexperiment );
  632. void  __vf ME_multiNonlinfitwW_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  633.                                     eVector X, eVector Y,
  634.                                     unsigned ipar, unsigned iexperiment );
  635. extended __vf VE_multiNonlinfit_getChi2( void );
  636. extended __vf VE_multiNonlinfitwW_getChi2( void );
  637. extended __vf ME_multiNonlinfit_getChi2( void );
  638. extended __vf ME_multiNonlinfitwW_getChi2( void );
  639. void     __vf VE_multiNonlinfit_getBestA( eVector ABest );
  640. void     __vf VE_multiNonlinfitwW_getBestA( eVector ABest );
  641. void     __vf ME_multiNonlinfit_getBestA( eVector ABest );
  642. void     __vf ME_multiNonlinfitwW_getBestA( eVector ABest );
  643. unsigned __vf VE_multiNonlinfit_getTestRun( void );
  644. unsigned __vf VE_multiNonlinfitwW_getTestRun( void );
  645. unsigned __vf ME_multiNonlinfit_getTestRun( void );
  646. unsigned __vf ME_multiNonlinfitwW_getTestRun( void );
  647. unsigned __vf VE_multiNonlinfit_getTestPar( void );
  648. unsigned __vf VE_multiNonlinfitwW_getTestPar( void );
  649. unsigned __vf ME_multiNonlinfit_getTestPar( void );
  650. unsigned __vf ME_multiNonlinfitwW_getTestPar( void );
  651. int      __vf VE_multiNonlinfit_getTestDir( void );
  652. int      __vf VE_multiNonlinfitwW_getTestDir( void );
  653. int      __vf ME_multiNonlinfit_getTestDir( void );
  654. int      __vf ME_multiNonlinfitwW_getTestDir( void );
  655. void     __vf VE_multiNonlinfit_stop( void );
  656. void     __vf VE_multiNonlinfitwW_stop( void );
  657. void     __vf ME_multiNonlinfit_stop( void );
  658. void     __vf ME_multiNonlinfitwW_stop( void );
  659.  
  660. /**************************  Input and Output  **************************/
  661.  
  662. #define ME_fprint( stream, MA, ht, len, linewidth ) \
  663.                     MEfprint( stream, MA[0], ht, len, linewidth )
  664. #define ME_print( MA, ht, len )  MEfprint( stdout, MA[0], ht, len, 80 )
  665.           /*  ME_print is usable only for DOS and EasyWin!  */
  666. #ifndef _Windows
  667.     #define ME_cprint( MA, ht, len ) MEcprint( MA[0], ht, len )
  668. #endif
  669.  
  670. #define ME_write( str, MA, ht, len )   MEwrite( str, MA[0], ht, len )
  671. #define ME_read( MA, ht, len, str )    MEread( MA[0], ht, len, str )
  672. #define ME_setWriteFormat              VE_setWriteFormat
  673. #define ME_setWriteSeparate            VE_setNWriteSeparate
  674.                                    /* write and read in ascii format */
  675. #define ME_store( str, MA, ht, len ) \
  676.                            VE_store( str, MA[0], ((ui) (len))*(ht) );
  677. #define ME_recall( MA, ht, len, str) \
  678.                            VE_recall( MA[0], ((ui) (len))*(ht), str);
  679.                                   /* store and recall in binary format */
  680.  
  681.  
  682. /*************************************************************************
  683.  * Here are now the actual declarations of the functions used internally.*
  684.  * These declarations may change in future versions of MatrixLib!        *
  685.  * You should not care too much about them, except in the case you need  *
  686.  * the actual address of a run-time function (see above). Under all      *
  687.  * "normal" circumstances, use only the names defined above in the       *
  688.  * macro section!                                                        *
  689.  *************************************************************************/
  690.  
  691. extended _VFAR * MEPelement( ePMatrix X, unsigned ht, unsigned len,
  692.                              unsigned m, unsigned n );
  693.                   /* pointer is normalized in memory model HUGE */
  694.  
  695. void   __vf  MEequ1( ePMatrix MA, unsigned len );  /* identity matrix */
  696. void   __vf  MEouterprod( ePMatrix MA, eVector X,  eVector Y,
  697.                           unsigned ht, unsigned len );
  698.  
  699. void   __vf  MERow_equC( ePMatrix MA, unsigned ht, unsigned len,
  700.                          unsigned iRow, extended C );
  701. void   __vf  MECol_equC( ePMatrix MA, unsigned ht, unsigned len,
  702.                          unsigned iCol, extended C );
  703. void   __vf  MEDia_equC( ePMatrix MA, unsigned len, extended C );
  704.  
  705. void   __vf  MERow_equV( ePMatrix MA, unsigned ht, unsigned len,
  706.                          unsigned iRow, eVector X );
  707. void   __vf  MECol_equV( ePMatrix MA, unsigned ht, unsigned len,
  708.                          unsigned iCol, eVector X );
  709. void   __vf  MEDia_equV( ePMatrix MA, unsigned len, eVector X );
  710.  
  711. void   __vf  MEUequL( ePMatrix MA, unsigned len );
  712. void   __vf  MELequU( ePMatrix MA, unsigned len );
  713.  
  714. void   __vf  MEHanning( ePMatrix MA, unsigned ht, unsigned len );
  715. void   __vf  MEParzen(  ePMatrix MA, unsigned ht, unsigned len );
  716. void   __vf  MEWelch(   ePMatrix MA, unsigned ht, unsigned len );
  717.  
  718. /********  Extracting a submatrix and copying a submatrix back  *********/
  719.  
  720. void  __vf  MEsubmatrix( ePMatrix MSub,
  721.                           unsigned subHt,  unsigned subLen,
  722.                           ePMatrix MSrce,
  723.                           unsigned srceHt,  unsigned srceLen,
  724.                           unsigned firstRowInCol,  unsigned sampInCol,
  725.                           unsigned firstColInRow,  unsigned sampInRow );
  726.  
  727. void  __vf  MEsubmatrix_equM( ePMatrix MDest,
  728.                                unsigned destHt,     unsigned destLen,
  729.                                unsigned firstRowInCol,  unsigned sampInCol,
  730.                                unsigned firstColInRow,  unsigned sampInRow,
  731.                                ePMatrix MSrce,
  732.                                unsigned srceHt,     unsigned srceLen );
  733.  
  734.  
  735. /*****   Extracting a single row or a single column or the diagonal  *****
  736.  *       and storing it into a vector                                    */
  737.  
  738. void __vf MERow_extract( eVector Y, ePMatrix MA, unsigned ht, unsigned len,
  739.                            unsigned iRow );
  740. void __vf MECol_extract( eVector Y, ePMatrix MA, unsigned ht, unsigned len,
  741.                            unsigned iCol );
  742. void __vf MEDia_extract( eVector Y, ePMatrix MA, unsigned len );
  743.  
  744.  
  745. /*****************    Basic arithmetic operations ***********************
  746.      performed on one single row,  or one single column of any matrix,
  747.      or on the diagonal of a square matrix                              */
  748.  
  749. void   __vf  MERow_addC( ePMatrix MA, unsigned ht, unsigned len,
  750.                          unsigned iRow, extended C );
  751. void   __vf  MECol_addC( ePMatrix MA, unsigned ht, unsigned len,
  752.                          unsigned iCol, extended C );
  753. void   __vf  MEDia_addC( ePMatrix MA, unsigned len, extended C );
  754.  
  755. void   __vf  MERow_subC( ePMatrix MA, unsigned ht, unsigned len,
  756.                          unsigned iRow, extended C );
  757. void   __vf  MECol_subC( ePMatrix MA, unsigned ht, unsigned len,
  758.                          unsigned iCol, extended C );
  759. void   __vf  MEDia_subC( ePMatrix MA, unsigned len, extended C );
  760.  
  761. void   __vf  MERow_addV( ePMatrix MA, unsigned ht, unsigned len,
  762.                          unsigned iRow, eVector X );
  763. void   __vf  MECol_addV( ePMatrix MA, unsigned ht, unsigned len,
  764.                          unsigned iCol, eVector X );
  765. void   __vf  MEDia_addV( ePMatrix MA, unsigned len, eVector X );
  766.  
  767. void   __vf  MERow_subV( ePMatrix MA, unsigned ht, unsigned len,
  768.                          unsigned iRow, eVector X );
  769. void   __vf  MECol_subV( ePMatrix MA, unsigned ht, unsigned len,
  770.                          unsigned iCol, eVector X );
  771. void   __vf  MEDia_subV( ePMatrix MA, unsigned len, eVector X );
  772.  
  773. void   __vf  MERow_subrC( ePMatrix MA, unsigned ht, unsigned len,
  774.                          unsigned iRow, extended C );
  775. void   __vf  MECol_subrC( ePMatrix MA, unsigned ht, unsigned len,
  776.                          unsigned iCol, extended C );
  777. void   __vf  MEDia_subrC( ePMatrix MA, unsigned len, extended C );
  778.  
  779. void   __vf  MERow_subrV( ePMatrix MA, unsigned ht, unsigned len,
  780.                          unsigned iRow, eVector X );
  781. void   __vf  MECol_subrV( ePMatrix MA, unsigned ht, unsigned len,
  782.                          unsigned iCol, eVector X );
  783. void   __vf  MEDia_subrV( ePMatrix MA, unsigned len, eVector X );
  784.  
  785. void   __vf  MERow_mulC( ePMatrix MA, unsigned ht, unsigned len,
  786.                          unsigned iRow, extended C );
  787. void   __vf  MECol_mulC( ePMatrix MA, unsigned ht, unsigned len,
  788.                          unsigned iCol, extended C );
  789. void   __vf  MEDia_mulC( ePMatrix MA, unsigned len, extended C );
  790.  
  791. void   __vf  MERow_mulV( ePMatrix MA, unsigned ht, unsigned len,
  792.                          unsigned iRow, eVector X );
  793. void   __vf  MECol_mulV( ePMatrix MA, unsigned ht, unsigned len,
  794.                          unsigned iCol, eVector X );
  795. void   __vf  MEDia_mulV( ePMatrix MA, unsigned len, eVector X );
  796.  
  797. void   __vf  MERow_divC( ePMatrix MA, unsigned ht, unsigned len,
  798.                          unsigned iRow, extended C );
  799. void   __vf  MECol_divC( ePMatrix MA, unsigned ht, unsigned len,
  800.                          unsigned iCol, extended C );
  801. void   __vf  MEDia_divC( ePMatrix MA, unsigned len, extended C );
  802.  
  803. void   __vf  MERow_divV( ePMatrix MA, unsigned ht, unsigned len,
  804.                          unsigned iRow, eVector X );
  805. void   __vf  MECol_divV( ePMatrix MA, unsigned ht, unsigned len,
  806.                          unsigned iCol, eVector X );
  807. void   __vf  MEDia_divV( ePMatrix MA, unsigned len, eVector X );
  808.  
  809. void   __vf  MERow_divrC( ePMatrix MA, unsigned ht, unsigned len,
  810.                          unsigned iRow, extended C );
  811. void   __vf  MECol_divrC( ePMatrix MA, unsigned ht, unsigned len,
  812.                          unsigned iCol, extended C );
  813. void   __vf  MEDia_divrC( ePMatrix MA, unsigned len, extended C );
  814.  
  815. void   __vf  MERow_divrV( ePMatrix MA, unsigned ht, unsigned len,
  816.                          unsigned iRow, eVector X );
  817. void   __vf  MECol_divrV( ePMatrix MA, unsigned ht, unsigned len,
  818.                          unsigned iCol, eVector X );
  819. void   __vf  MEDia_divrV( ePMatrix MA, unsigned len, eVector X );
  820.  
  821.  
  822. /******  One-dimensional vector operations **********************
  823.          performed along all rows or all columns simultaneously,
  824.          or along the diagonal of a square matrix                */
  825.  
  826. void  __vf  MERows_max( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  827. void  __vf  MECols_max( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  828. extended __vf  MEDia_max(  ePMatrix MA, unsigned len );
  829. void  __vf  MERows_min( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  830. void  __vf  MECols_min( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  831. extended __vf  MEDia_min(  ePMatrix MA, unsigned len );
  832.  
  833. void  __vf  MERows_absmax( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  834. void  __vf  MECols_absmax( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  835. extended __vf  MEDia_absmax(  ePMatrix MA, unsigned len );
  836. void  __vf  MERows_absmin( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  837. void  __vf  MECols_absmin( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  838. extended __vf  MEDia_absmin(  ePMatrix MA, unsigned len );
  839.  
  840. void  __vf  MERows_sum( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  841. void  __vf  MECols_sum( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  842. extended __vf  MEDia_sum(  ePMatrix MA, unsigned len );
  843. void  __vf  MERows_prod(eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  844. void  __vf  MECols_prod(eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  845. extended __vf  MEDia_prod( ePMatrix MA, unsigned len );
  846.  
  847. void  __vf  MERows_runsum( ePMatrix MA, unsigned ht, unsigned len );
  848. void  __vf  MECols_runsum( ePMatrix MA, unsigned ht, unsigned len );
  849. void  __vf  MERows_runprod( ePMatrix MA, unsigned ht, unsigned len );
  850. void  __vf  MECols_runprod( ePMatrix MA, unsigned ht, unsigned len );
  851.  
  852. void  __vf  MERows_rotate( ePMatrix MA, unsigned ht, unsigned len, int pos );
  853. void  __vf  MECols_rotate( ePMatrix MA, unsigned ht, unsigned len, int pos );
  854. void  __vf  MERows_reflect( ePMatrix MA, unsigned ht, unsigned len );
  855. void  __vf  MECols_reflect( ePMatrix MA, unsigned ht, unsigned len );
  856.  
  857. /********  Operations involving two rows or two colums of one matrix  *****/
  858.  
  859. void   __vf  MERows_exchange( ePMatrix MA, unsigned ht, unsigned len,
  860.                               unsigned i1, unsigned i2 );
  861. void   __vf  MECols_exchange( ePMatrix MA, unsigned ht, unsigned len,
  862.                               unsigned i1, unsigned i2 );
  863.  
  864. void   __vf  MERows_add( ePMatrix MA, unsigned ht, unsigned len,
  865.                           unsigned destRow, unsigned sourceRow );
  866. void   __vf  MECols_add( ePMatrix MA, unsigned ht, unsigned len,
  867.                           unsigned destCol, unsigned sourceCol );
  868.  
  869. void   __vf  MERows_sub( ePMatrix MA, unsigned ht, unsigned len,
  870.                           unsigned destRow, unsigned sourceRow );
  871. void   __vf  MECols_sub( ePMatrix MA, unsigned ht, unsigned len,
  872.                           unsigned destCol, unsigned sourceCol );
  873.  
  874. void   __vf  MERows_Cadd( ePMatrix MA, unsigned ht, unsigned len,
  875.                            unsigned destRow, unsigned sourceRow, extended C );
  876. void   __vf  MECols_Cadd( ePMatrix MA, unsigned ht, unsigned len,
  877.                            unsigned destCol, unsigned sourceCol, extended C );
  878.  
  879. void   __vf  MERows_lincomb( ePMatrix MA, unsigned ht, unsigned len,
  880.                               unsigned destRow,  extended  destC,
  881.                               unsigned srceRow,  extended  srceC );
  882. void   __vf  MECols_lincomb( ePMatrix MA, unsigned ht, unsigned len,
  883.                               unsigned destCol,  extended  destC,
  884.                               unsigned srceCol,  extended  srceC );
  885.  
  886.  
  887. /*************************  Transposing a matrix **********************/
  888.  
  889. void  __vf  MEtranspose( ePMatrix MTr, ePMatrix MA,
  890.                           unsigned htTr, unsigned lenTr );
  891.  
  892.  
  893. /************************ Matrix Multiplication *************************/
  894.  
  895. void  __vf  MEmulV( eVector Y, ePMatrix MA, eVector X,
  896.                     unsigned htA, unsigned lenA );
  897. void  __vf  VEmulM( eVector Y, eVector X, ePMatrix MA,
  898.                     unsigned sizX, unsigned lenA );
  899. void  __vf  MEmulM( ePMatrix MC, ePMatrix MA, ePMatrix MB,
  900.                       unsigned htA, unsigned lenA, unsigned lenB );
  901.  
  902.  
  903. /*************************  Linear Algebra    *****************************/
  904.  
  905. int    __vf  MELUdecompose( ePMatrix MLU,  uiVector Ind, ePMatrix MA,
  906.                             unsigned len );
  907.  
  908. void     __vf  MELUsolve( eVector X, ePMatrix MLU, eVector B, uiVector Ind,
  909.                           unsigned len );
  910. void     __vf  MELUinv( ePMatrix MInv, ePMatrix MLU, uiVector Ind,
  911.                         unsigned len );
  912. extended __vf  MELUdet( ePMatrix MLU, unsigned len, int permut );
  913. void     __vf  MELUimprove( eVector X, eVector B, ePMatrix MA, ePMatrix MLU,
  914.                             uiVector Ind, unsigned len );
  915.  
  916. int   __vf  MESVdecompose( ePMatrix MU, ePMatrix MV, eVector W, ePMatrix MA,
  917.                            unsigned htA, unsigned lenA );
  918. void  __vf  MESVsolve( eVector X, ePMatrix MU, ePMatrix MV, eVector W,
  919.                        eVector B, unsigned htU, unsigned lenU );
  920. void  __vf  MESVimprove(  eVector X, eVector B, ePMatrix MA,
  921.                        ePMatrix MU, ePMatrix MV, eVector W,
  922.                        unsigned htA, unsigned lenA );
  923.  
  924.           /*  functions using LUD or SVD     */
  925. int    __vf  MEsolve( eVector X, ePMatrix MA, eVector B, unsigned len );
  926.                   /* ret.value != 0 signals error */
  927. int    __vf  MEinv( ePMatrix MInv, ePMatrix MA, unsigned len );
  928.                  /* ret.value != 0 signals error */
  929. extended  __vf  MEdet( ePMatrix MA, unsigned len );
  930.  
  931. int    __vf  MEsolveBySVD( eVector X, ePMatrix MA, eVector B,
  932.                            unsigned ht, unsigned len );
  933.                  /*  ret.value != 0 signals failure */
  934. int    __vf  MEsafeSolve( eVector X, ePMatrix MA, eVector B, unsigned len );
  935.               /* ret.value 0: success via LUD; 1: success via SVD; -1: error */
  936.  
  937.        /*********  Eigenvalues and Eigenvectors  ********/
  938.  
  939. void __vf MEs_eigenvalues( eVector EigV, ePMatrix EigM, ePMatrix MA, unsigned len,
  940.                         int CalcEigenVec );
  941.  
  942. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  943.  
  944. void  __vf   MElFFT( ePMatrix MY, ePMatrix MX,
  945.                      unsigned ht, unsigned len, int dir );
  946. void  __vf   MElconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  947.                           ePMatrix MRsp, unsigned ht, unsigned len );
  948. void  __vf   MEldeconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  949.                             ePMatrix MRsp, unsigned ht, unsigned len );
  950. void  __vf   MElfilter( ePMatrix MY, ePMatrix MX, ePMatrix MFlt,
  951.                         unsigned ht, unsigned len );
  952. void  __vf   MElautocorr( ePMatrix MACorr, ePMatrix MX,
  953.                           unsigned ht, unsigned len );
  954. void  __vf   MElxcorr( ePMatrix MXCorr, ePMatrix MX, ePMatrix MY,
  955.                        unsigned ht, unsigned len );
  956. void  __vf   MElspectrum( ePMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  957.                           ePMatrix MX, unsigned htX, unsigned lenX,
  958.                           ePMatrix MWin );
  959.  
  960. void  __vf   MEsFFT( ePMatrix MY, ePMatrix MX,
  961.                      unsigned ht, unsigned len, int dir );
  962. void  __vf   MEsconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  963.                           ePMatrix MRsp, unsigned ht, unsigned len );
  964. void  __vf   MEsdeconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  965.                             ePMatrix MRsp, unsigned ht, unsigned len );
  966. void  __vf   MEsfilter( ePMatrix MY, ePMatrix MX, ePMatrix MFlt,
  967.                         unsigned ht, unsigned len );
  968. void  __vf   MEsautocorr( ePMatrix MACorr, ePMatrix MX,
  969.                           unsigned ht, unsigned len );
  970. void  __vf   MEsxcorr( ePMatrix MXCorr, ePMatrix MX, ePMatrix MY,
  971.                        unsigned ht, unsigned len );
  972. void  __vf   MEsspectrum( ePMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  973.                           ePMatrix MX, unsigned htX, unsigned lenX,
  974.                           ePMatrix MWin );
  975.  
  976.       /***************  Data Fitting    ******************/
  977.  
  978. void __vf VEpolyfitwW( eVector A, ePMatrix Covar, unsigned deg,
  979.                         eVector X, eVector Y, eVector InvVar, ui sizex );
  980. void __vf VElinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  981.                     eVector X, eVector Y, eVector InvVar, ui sizex,
  982.                     void (*funcs)(eVector BasFuncs, extended x, unsigned nfuncs) );
  983. extended __vf VEnonlinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  984.                     eVector X, eVector Y, eVector InvVar, ui sizex,
  985.                     void (*modelfunc)(eVector YModel, eVector X, ui size),
  986.                     void (*derivatives)(eVector dYdAi, eVector X, ui size, unsigned i) );
  987. void __vf MElinfit( eVector A, iVector AStatus, unsigned npars,
  988.                     eVector X, eVector Y, ePMatrix MZ, unsigned htZ, unsigned lenZ,
  989.                     void (*funcs)(eVector BasFuncs, extended x, extended y, unsigned nfuncs) );
  990. extended __vf MEnonlinfit( eVector A, iVector AStatus, unsigned npars,
  991.                     eVector X, eVector Y, ePMatrix MZ, unsigned htZ, unsigned lenZ,
  992.                     void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ, eVector X, eVector Y ),
  993.                     void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned i) );
  994. void __vf MElinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  995.                       eVector X, eVector Y, ePMatrix MZ, ePMatrix MInvVar, unsigned htZ, unsigned lenZ,
  996.                       void (*funcs)(eVector BasFuncs, extended x, extended y, unsigned nfuncs) );
  997. extended __vf MEnonlinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  998.                     eVector X, eVector Y, ePMatrix MZ, ePMatrix MInvVar, unsigned htZ, unsigned lenZ,
  999.                     void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ, eVector X, eVector Y ),
  1000.                     void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned i) );
  1001.  
  1002. void __vf VEmultiLinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned ma,
  1003.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1004.                 void (*funcs)(eVector BasFuncs, extended x,
  1005.                               unsigned nfuncs, unsigned nexperiment) );
  1006. void __vf MEmultiLinfitwW( eVector A, ePMatrix Covar,
  1007.                 iVector AStatus, unsigned npars,
  1008.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1009.                 void (*funcs)(eVector BasFuncs, extended x, extended y,
  1010.                               unsigned nfuncs, unsigned nexperiment) );
  1011. extended __vf VEmultiNonlinfitwW( eVector A, ePMatrix Covar,
  1012.                 iVector AStatus, unsigned npars,
  1013.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1014.                 void (*modelfunc)(eVector YModel, eVector X, ui size,
  1015.                                   unsigned iexperiment),
  1016.                 void (*derivatives)(eVector dYdAi, eVector X, ui size,
  1017.                                   unsigned ipar, unsigned iexperiment) );
  1018. extended __vf MEmultiNonlinfitwW( eVector A, ePMatrix Covar,
  1019.                 iVector AStatus, unsigned npars,
  1020.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1021.                 void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ,
  1022.                                   eVector X, eVector Y, unsigned iexperiment ),
  1023.                 void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  1024.                                     eVector X, eVector Y,
  1025.                                     unsigned ipar, unsigned iexperiment) );
  1026.  
  1027.       /*************  Input and Output  ****************/
  1028.  
  1029. void __vf MEfprint( FILE _VFAR *stream, ePMatrix MA, unsigned ht,
  1030.                     unsigned len, unsigned linewidth );
  1031. #ifndef _Windows
  1032.     void __vf MEcprint( ePMatrix MA, unsigned ht, unsigned len );
  1033. #endif
  1034. void  __vf    MEwrite( FILE _VFAR *stream, ePMatrix X, unsigned ht, unsigned len  );
  1035. void  __vf    MEread( ePMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  1036.  
  1037. #ifdef __cplusplus
  1038. }
  1039. #endif
  1040. #endif /* __MESTD_H */
  1041.